home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / WindowMaker / WPrefs.app / Appearance.c next >
Encoding:
C/C++ Source or Header  |  2000-01-14  |  55.7 KB  |  2,264 lines
  1. /* Apperance.c- color/texture for titlebar etc.
  2.  * 
  3.  *  WPrefs - Window Maker Preferences Program
  4.  * 
  5.  *  Copyright (c) 1999 Alfredo K. Kojima
  6.  * 
  7.  *  This program is free software; you can redistribute it and/or modify
  8.  *  it under the terms of the GNU General Public License as published by
  9.  *  the Free Software Foundation; either version 2 of the License, or
  10.  *  (at your option) any later version.
  11.  *
  12.  *  This program is distributed in the hope that it will be useful,
  13.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *  GNU General Public License for more details.
  16.  *
  17.  *  You should have received a copy of the GNU General Public License
  18.  *  along with this program; if not, write to the Free Software
  19.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 
  20.  *  USA.
  21.  */
  22.  
  23.  
  24. #include "WPrefs.h"
  25.  
  26. #include <unistd.h>
  27. #include <errno.h>
  28. #include <ctype.h>
  29. #include <time.h>
  30. #include <sys/stat.h>
  31. #include <sys/types.h>
  32. #include <fcntl.h>
  33. #include <unistd.h>
  34.  
  35.  
  36.  
  37.  
  38. #include "TexturePanel.h"
  39.  
  40. typedef struct _Panel {
  41.     WMFrame *frame;
  42.     char *sectionName;
  43.  
  44.     char *description;
  45.  
  46.     CallbackRec callbacks;
  47.  
  48.     WMWindow *win;
  49.  
  50.     WMLabel *prevL;
  51.  
  52.  
  53.     WMTabView *tabv;
  54.  
  55.     /* texture list */
  56.     WMFrame *texF;
  57.     WMList *texLs;
  58.  
  59.     WMPopUpButton *secP;
  60.  
  61.     WMButton *newB;
  62.     WMButton *editB;
  63.     WMButton *ripB;
  64.     WMButton *delB;
  65.  
  66.     /* text color */
  67.     WMFrame *colF;
  68.  
  69.     WMPopUpButton *colP;
  70.     WMColor *colors[14];
  71.  
  72.     WMColorWell *colW;
  73.  
  74.     WMColorWell *sampW[24];
  75.  
  76.     /* options */
  77.     WMFrame *optF;
  78.  
  79.     WMFrame *mstyF;
  80.     WMButton *mstyB[3];
  81.  
  82.     WMFrame *taliF;
  83.     WMButton *taliB[3];
  84.  
  85.     /* */
  86.  
  87.     int textureIndex[8];
  88.  
  89.     WMFont *smallFont;
  90.     WMFont *normalFont;
  91.     WMFont *boldFont;
  92.  
  93.     TexturePanel *texturePanel;
  94.  
  95.     WMPixmap *onLed;
  96.     WMPixmap *offLed;
  97.     WMPixmap *hand;
  98.  
  99.     int oldsection;
  100.     int oldcsection;
  101.  
  102.     char oldTabItem;
  103.  
  104.     char menuStyle;
  105.  
  106.     char titleAlignment;
  107.  
  108.     Pixmap preview;
  109.  
  110.     char *fprefix;
  111. } _Panel;
  112.  
  113.  
  114. typedef struct {
  115.     char *title;
  116.     char *texture;
  117.     proplist_t prop;
  118.     Pixmap preview;
  119.  
  120.     char *path;
  121.  
  122.     char selectedFor;
  123.     unsigned current:1;
  124.     unsigned ispixmap:1;
  125. } TextureListItem;
  126.  
  127. static void updateColorPreviewBox(_Panel *panel, int elements);
  128.  
  129. static void showData(_Panel *panel);
  130.  
  131. static void changePage(WMWidget *w, void *data);
  132.  
  133. static void changeColorPage(WMWidget *w, void *data);
  134.  
  135. static void OpenExtractPanelFor(_Panel *panel, char *path);
  136.  
  137.  
  138.  
  139. static void changedTabItem(struct WMTabViewDelegate *self, WMTabView *tabView,
  140.                WMTabViewItem *item);
  141.  
  142.  
  143.  
  144. static WMTabViewDelegate tabviewDelegate = {
  145.     NULL,
  146.     NULL, /* didChangeNumberOfItems */
  147.     changedTabItem, /* didSelectItem */
  148.     NULL, /* shouldSelectItem */
  149.     NULL /* willSelectItem */
  150. };
  151.  
  152.  
  153. #define ICON_FILE    "appearance"
  154.  
  155. #define TNEW_FILE     "tnew"
  156. #define TDEL_FILE    "tdel"
  157. #define TEDIT_FILE    "tedit"
  158. #define TEXTR_FILE     "textr"
  159.  
  160. #define MSTYLE1_FILE    "msty1"
  161. #define MSTYLE2_FILE    "msty2"
  162. #define MSTYLE3_FILE    "msty3"
  163.  
  164.  
  165. /* XPM */
  166. static char * blueled_xpm[] = {
  167. "8 8 17 1",
  168. "     c None",
  169. ".    c #020204",
  170. "+    c #16B6FC",
  171. "@    c #176AFC",
  172. "#    c #163AFC",
  173. "$    c #72D2FC",
  174. "%    c #224CF4",
  175. "&    c #76D6FC",
  176. "*    c #16AAFC",
  177. "=    c #CEE9FC",
  178. "-    c #229EFC",
  179. ";    c #164CFC",
  180. ">    c #FAFEFC",
  181. ",    c #2482FC",
  182. "'    c #1652FC",
  183. ")    c #1E76FC",
  184. "!    c #1A60FC",
  185. "  ....  ",
  186. " .=>-@. ",
  187. ".=>$@@'.",
  188. ".=$@!;;.",
  189. ".!@*+!#.",
  190. ".#'*+*,.",
  191. " .@)@,. ",
  192. "  ....  "};
  193.  
  194.  
  195. /* XPM */
  196. static char *blueled2_xpm[] = {
  197. /* width height num_colors chars_per_pixel */
  198. "     8     8       17            1",
  199. /* colors */
  200. ". c None",
  201. "# c #090909",
  202. "a c #4b63a4",
  203. "b c #011578",
  204. "c c #264194",
  205. "d c #04338c",
  206. "e c #989dac",
  207. "f c #011a7c",
  208. "g c #465c9c",
  209. "h c #03278a",
  210. "i c #6175ac",
  211. "j c #011e74",
  212. "k c #043a90",
  213. "l c #042f94",
  214. "m c #0933a4",
  215. "n c #022184",
  216. "o c #012998",
  217. /* pixels */
  218. "..####..",
  219. ".#aimn#.",
  220. "#aechnf#",
  221. "#gchnjf#",
  222. "#jndknb#",
  223. "#bjdddl#",
  224. ".#nono#.",
  225. "..####.."
  226. };
  227.  
  228.  
  229. /* XPM */
  230. static char * hand_xpm[] = {
  231. "22 21 19 1",
  232. "       c None",
  233. ".      c #030305",
  234. "+      c #7F7F7E",
  235. "@      c #B5B5B6",
  236. "#      c #C5C5C6",
  237. "$      c #969697",
  238. "%      c #FDFDFB",
  239. "&      c #F2F2F4",
  240. "*      c #E5E5E4",
  241. "=      c #ECECEC",
  242. "-      c #DCDCDC",
  243. ";      c #D2D2D0",
  244. ">      c #101010",
  245. ",      c #767674",
  246. "'      c #676767",
  247. ")      c #535355",
  248. "!      c #323234",
  249. "~      c #3E3C56",
  250. "{      c #333147",
  251. "                      ",
  252. "       .....          ",
  253. "     ..+@##$.         ",
  254. "    .%%%&@..........  ",
  255. "   .%*%%&#%%%%%%%%%$. ",
  256. "  .*#%%%%%%%%%&&&&==. ",
  257. " .-%%%%%%%%%=*-;;;#$. ",
  258. " .-%%%%%%%%&..>.....  ",
  259. " >-%%%%%%%%%*#+.      ",
  260. " >-%%%%%%%%%*@,.      ",
  261. " >#%%%%%%%%%*@'.      ",
  262. " >$&&%%%%%%=...       ",
  263. " .+@@;=&%%&;$,>       ",
  264. "  .',$@####$+).       ",
  265. "   .!',+$++,'.        ",
  266. "     ..>>>>>.         ",
  267. "                      ",
  268. "     ~~{{{~~          ",
  269. "   {{{{{{{{{{{        ",
  270. "     ~~{{{~~          ",
  271. "                      "};
  272.  
  273.  
  274.  
  275. static char *sampleColors[] = {
  276.     "black",
  277.     "#292929",
  278.     "#525252",
  279.     "#848484",
  280.     "#adadad",
  281.     "#d6d6d6",
  282.     "white",
  283.     "#d6d68c",
  284.     "#d6a57b",
  285.     "#8cd68c",
  286.     "#8cd6ce",
  287.     "#d68c8c",
  288.     "#8c9cd6",
  289.     "#bd86d6",
  290.     "#d68cbd",
  291.     "#d64a4a",
  292.     "#4a5ad6",
  293.     "#4ad6ce",
  294.     "#4ad65a",
  295.     "#ced64a",
  296.     "#d6844a",
  297.     "#8ad631",
  298.     "#ce29c6",
  299.     "#ce2973",
  300.     "black"
  301. };
  302.  
  303.  
  304. static char *textureOptions[] = {
  305.     "FTitleBack", "(solid, black)", "[Focused]", 
  306.     "UTitleBack", "(solid, gray)", "[Unfocused]",
  307.     "PTitleBack", "(solid, \"#616161\")", "[Owner of Focused]",
  308.     "ResizebarBack", "(solid, gray)", "[Resizebar]",
  309.     "MenuTitleBack", "(solid, black)", "[Menu Title]",
  310.     "MenuTextBack", "(solid, gray)", "[Menu Item]",
  311.     "IconBack", "(solid, gray)", "[Icon]"
  312. };
  313.  
  314.  
  315. #define RESIZEBAR_BEVEL    -1
  316. #define MENU_BEVEL     -2
  317.  
  318. #define TEXPREV_WIDTH    40
  319. #define TEXPREV_HEIGHT    24
  320.  
  321.  
  322. #define MSTYLE_NORMAL    0
  323. #define MSTYLE_SINGLE    1
  324. #define MSTYLE_FLAT    2
  325.  
  326.  
  327. #define FTITLE_COL    (1<<0)
  328. #define UTITLE_COL    (1<<1)
  329. #define OTITLE_COL    (1<<2)
  330. #define MTITLE_COL    (1<<3)
  331. #define MITEM_COL    (1<<4)
  332. #define MDISAB_COL    (1<<5)
  333. #define MHIGH_COL    (1<<6)
  334. #define MHIGHT_COL    (1<<7)
  335. #define ICONT_COL    (1<<8)
  336. #define ICONB_COL    (1<<9)
  337. #define CLIP_COL    (1<<10)
  338. #define CCLIP_COL    (1<<11)
  339.  
  340.  
  341. static char *colorOptions[] = {
  342.     "FTitleColor", "white",
  343.     "UTitleColor", "black",
  344.     "PTitleColor", "white",
  345.     "MenuTitleColor", "white",
  346.     "MenuTextColor", "black",
  347.     "MenuDisabledColor", "#616161",
  348.     "HighlightColor", "white",
  349.     "HighlightTextColor", "black",
  350.     "IconTitleColor", "white",
  351.     "IconTitleBack", "black",
  352.     "ClipTitleColor", "black",
  353.     "CClipTitleColor", "#454045"
  354. };
  355.  
  356.  
  357.  
  358.  
  359. static WMRect previewPositions[] = {
  360. #define PFOCUSED    0
  361.     {{30,10},{190, 20}},
  362. #define PUNFOCUSED    1
  363.     {{30,40},{190,20}},
  364. #define POWNER        2
  365.     {{30,70},{190,20}},
  366. #define PRESIZEBAR    3
  367.     {{30,100},{190,9}},
  368. #define PMTITLE        4
  369.     {{30,120},{90,20}},
  370. #define PMITEM        5
  371.     {{30,140},{90,20*4}},
  372. #define PICON        6
  373.     {{155,130},{64,64}}
  374. };
  375. #define EVERYTHING    0xff
  376.  
  377.  
  378. static WMRect previewColorPositions[] = {
  379.     {{30,10},{190, 20}},
  380.     {{30,40},{190,20}},
  381.     {{30,70},{190,20}},
  382.     {{30,120},{90,20}},
  383.     {{30,140},{90,20}},
  384.     {{30,160},{90,20}},
  385.     {{30,180},{90,20}},
  386.     {{30,200},{90,20}},
  387.     {{155,130},{64,64}},
  388.     {{155,130},{64,64}},
  389.     {{155,130},{64,64}},
  390.     {{155,130},{64,64}}
  391. };
  392.  
  393.  
  394.  
  395. static void
  396. str2rcolor(RContext *rc, char *name, RColor *color)
  397. {
  398.     XColor xcolor;
  399.     
  400.     XParseColor(rc->dpy, rc->cmap, name, &xcolor);
  401.  
  402.     color->alpha = 255;
  403.     color->red = xcolor.red >> 8;
  404.     color->green = xcolor.green >> 8;
  405.     color->blue = xcolor.blue >> 8;
  406. }
  407.  
  408.  
  409. static void
  410. dumpRImage(char *path, RImage *image)
  411. {
  412.     FILE *f;
  413.     int channels = (image->format == RRGBAFormat ? 4 : 3);
  414.  
  415.     f = fopen(path, "w");
  416.     if (!f) {
  417.     wsyserror(path);
  418.     return;
  419.     }
  420.     fprintf(f, "%02x%02x%1x", image->width, image->height, channels);
  421.  
  422.     fwrite(image->data, 1, image->width * image->height * channels, f);
  423.  
  424.     if (fclose(f) < 0) {
  425.     wsyserror(path);
  426.     }
  427. }
  428.  
  429.  
  430.  
  431. static int
  432. isPixmap(proplist_t prop)
  433. {
  434.     proplist_t p;
  435.     char *s;
  436.  
  437.     p = PLGetArrayElement(prop, 0);
  438.     s = PLGetString(p);
  439.     if (strcasecmp(&s[1], "pixmap")==0)
  440.     return 1;
  441.     else
  442.     return 0;
  443. }
  444.  
  445.  
  446. /**********************************************************************/
  447.  
  448. static void
  449. drawResizebarBevel(RImage *img)
  450. {
  451.     RColor light;
  452.     RColor dark;
  453.     RColor black;
  454.     int width = img->width;
  455.     int height = img->height;
  456.     int cwidth = 28;
  457.  
  458.     black.alpha = 255;
  459.     black.red = black.green = black.blue = 0;
  460.     
  461.     light.alpha = 0;
  462.     light.red = light.green = light.blue = 80;
  463.  
  464.     dark.alpha = 0;
  465.     dark.red = dark.green = dark.blue = 40;
  466.  
  467.     ROperateLine(img, RSubtractOperation, 0, 0, width-1, 0, &dark);
  468.     ROperateLine(img, RAddOperation, 0, 1, width-1, 1, &light);
  469.  
  470.     ROperateLine(img, RSubtractOperation, cwidth, 2, cwidth, height-1, &dark);
  471.     ROperateLine(img, RAddOperation, cwidth+1, 2, cwidth+1, height-1, &light);
  472.  
  473.     ROperateLine(img, RSubtractOperation, width-cwidth-2, 2, width-cwidth-2,
  474.          height-1, &dark);
  475.     ROperateLine(img, RAddOperation, width-cwidth-1, 2, width-cwidth-1, 
  476.          height-1, &light);
  477.     
  478.     RDrawLine(img, 0, height-1, width-1, height-1, &black);
  479.     RDrawLine(img, 0, 0, 0, height-1, &black);
  480.     RDrawLine(img, width-1, 0, width-1, height-1, &black);
  481. }
  482.  
  483.  
  484. static void
  485. drawMenuBevel(RImage *img)
  486. {
  487.     RColor light, dark, mid;
  488.     int i;
  489.     int iheight = img->height / 4;
  490.     
  491.     light.alpha = 0;
  492.     light.red = light.green = light.blue = 80;
  493.     
  494.     dark.alpha = 255;
  495.     dark.red = dark.green = dark.blue = 0;
  496.     
  497.     mid.alpha = 0;
  498.     mid.red = mid.green = mid.blue = 40;
  499.     
  500.     for (i = 1; i < 4; i++) {
  501.     ROperateLine(img, RSubtractOperation, 0, i*iheight-2,
  502.              img->width-1, i*iheight-2, &mid);
  503.     
  504.     RDrawLine(img, 0, i*iheight-1, img->width-1, i*iheight-1, &dark);
  505.     
  506.     ROperateLine(img, RAddOperation, 1, i*iheight,
  507.              img->width-2, i*iheight, &light);
  508.     }
  509. }
  510.  
  511.  
  512. static Pixmap
  513. renderTexture(WMScreen *scr, proplist_t texture, int width, int height,
  514.           char *path, int border)
  515. {
  516.     char *type;
  517.     RImage *image = NULL;
  518.     Pixmap pixmap;
  519.     RContext *rc = WMScreenRContext(scr);
  520.     char *str;
  521.     RColor rcolor;
  522.  
  523.  
  524.     type = PLGetString(PLGetArrayElement(texture, 0));
  525.  
  526.     if (strcasecmp(type, "solid")==0) {
  527.  
  528.     str = PLGetString(PLGetArrayElement(texture, 1));
  529.  
  530.     str2rcolor(rc, str, &rcolor);
  531.  
  532.     image = RCreateImage(width, height, False);
  533.     RClearImage(image, &rcolor);
  534.     } else if (strcasecmp(&type[1], "gradient")==0) {
  535.     int style;
  536.     RColor rcolor2;
  537.  
  538.     switch (toupper(type[0])) {
  539.      case 'V':
  540.         style = RVerticalGradient;
  541.         break;
  542.      case 'H':
  543.         style = RHorizontalGradient;
  544.         break;
  545.      default:
  546.      case 'D':
  547.         style = RDiagonalGradient;
  548.         break;
  549.     }
  550.  
  551.     str = PLGetString(PLGetArrayElement(texture, 1));
  552.     str2rcolor(rc, str, &rcolor);
  553.     str = PLGetString(PLGetArrayElement(texture, 2));
  554.     str2rcolor(rc, str, &rcolor2);
  555.  
  556.     image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
  557.     } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='T') {
  558.     int style;
  559.     RColor rcolor2;
  560.     int i;
  561.     RImage *grad, *timage;
  562.     char *path;
  563.  
  564.     switch (toupper(type[1])) {
  565.      case 'V':
  566.         style = RVerticalGradient;
  567.         break;
  568.      case 'H':
  569.         style = RHorizontalGradient;
  570.         break;
  571.      default:
  572.      case 'D':
  573.         style = RDiagonalGradient;
  574.         break;
  575.     }
  576.  
  577.     str = PLGetString(PLGetArrayElement(texture, 3));
  578.     str2rcolor(rc, str, &rcolor);
  579.     str = PLGetString(PLGetArrayElement(texture, 4));
  580.     str2rcolor(rc, str, &rcolor2);
  581.  
  582.     str = PLGetString(PLGetArrayElement(texture, 1));
  583.  
  584.     if ((path=wfindfileinarray(GetObjectForKey("PixmapPath"), str))!=NULL)
  585.             timage = RLoadImage(rc, path, 0);
  586.  
  587.     if (!path || !timage) {
  588.         wwarning("could not load file '%s': %s", path,
  589.              RMessageForError(RErrorCode));
  590.     } else {    
  591.         grad = RRenderGradient(width, height, &rcolor, &rcolor2, style);
  592.  
  593.         image = RMakeTiledImage(timage, width, height);
  594.         RDestroyImage(timage);
  595.  
  596.         i = atoi(PLGetString(PLGetArrayElement(texture, 2)));
  597.     
  598.         RCombineImagesWithOpaqueness(image, grad, i);
  599.         RDestroyImage(grad);
  600.     }
  601.     } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='M') {
  602.     int style;
  603.     RColor **colors;
  604.     int i, j;
  605.  
  606.     switch (toupper(type[1])) {
  607.      case 'V':
  608.         style = RVerticalGradient;
  609.         break;
  610.      case 'H':
  611.         style = RHorizontalGradient;
  612.         break;
  613.      default:
  614.      case 'D':
  615.         style = RDiagonalGradient;
  616.         break;
  617.     }
  618.  
  619.     j = PLGetNumberOfElements(texture);
  620.     
  621.     if (j > 0) {
  622.         colors = wmalloc(j * sizeof(RColor*));
  623.  
  624.         for (i = 2; i < j; i++) {
  625.         str = PLGetString(PLGetArrayElement(texture, i));
  626.         colors[i-2] = wmalloc(sizeof(RColor));
  627.         str2rcolor(rc, str, colors[i-2]);
  628.         }
  629.         colors[i-2] = NULL;
  630.  
  631.         image = RRenderMultiGradient(width, height, colors, style);
  632.         
  633.         for (i = 0; colors[i]!=NULL; i++)
  634.         free(colors[i]);
  635.         free(colors);
  636.     }
  637.     } else if (strcasecmp(&type[1], "pixmap")==0) {
  638.     RImage *timage = NULL;
  639.     char *path;
  640.     RColor color;
  641.  
  642.     str = PLGetString(PLGetArrayElement(texture, 1));
  643.  
  644.     if ((path=wfindfileinarray(GetObjectForKey("PixmapPath"), str))!=NULL)
  645.             timage = RLoadImage(rc, path, 0);
  646.  
  647.     if (!path || !timage) {
  648.         wwarning("could not load file '%s': %s", path ? path : str,
  649.              RMessageForError(RErrorCode));
  650.     } else {
  651.         str = PLGetString(PLGetArrayElement(texture, 2));
  652.         str2rcolor(rc, str, &color);
  653.  
  654.         switch (toupper(type[0])) {
  655.          case 'T':
  656.         image = RMakeTiledImage(timage, width, height);
  657.         RDestroyImage(timage);
  658.         timage = image;
  659.         break;
  660.          case 'C':
  661.         image = RMakeCenteredImage(timage, width, height, &color);
  662.         RDestroyImage(timage);
  663.         timage = image;
  664.         break;
  665.          case 'S':
  666.          case 'M':
  667.         image = RScaleImage(timage, width, height);
  668.         RDestroyImage(timage);
  669.         timage = image;
  670.         break;
  671.         }
  672.  
  673.     }
  674.     free(path);
  675.     }
  676.  
  677.     if (!image)
  678.     return None;
  679.  
  680.     if (path) {
  681.     dumpRImage(path, image);
  682.     }
  683.     
  684.     if (border < 0) {
  685.     if (border == RESIZEBAR_BEVEL) {
  686.         drawResizebarBevel(image);
  687.     } else if (border == MENU_BEVEL) {
  688.         drawMenuBevel(image);
  689.         RBevelImage(image, RBEV_RAISED2);
  690.     }
  691.     } else if (border) {
  692.     RBevelImage(image, border);
  693.     }
  694.  
  695.     RConvertImage(rc, image, &pixmap);
  696.     RDestroyImage(image);
  697.  
  698.     return pixmap;
  699. }
  700.  
  701.  
  702. static Pixmap
  703. renderMenu(_Panel *panel, proplist_t texture, int width, int iheight)
  704. {
  705.     WMScreen *scr = WMWidgetScreen(panel->win);
  706.     Display *dpy = WMScreenDisplay(scr);
  707.     Pixmap pix, tmp;
  708.     GC gc = XCreateGC(dpy, WMWidgetXID(panel->win), 0, NULL);
  709.     int i;
  710.  
  711.     switch (panel->menuStyle) {
  712.      case MSTYLE_NORMAL:
  713.     tmp = renderTexture(scr, texture, width, iheight, NULL, RBEV_RAISED2);
  714.  
  715.     pix = XCreatePixmap(dpy, tmp, width, iheight*4, WMScreenDepth(scr));
  716.     for (i = 0; i < 4; i++) {
  717.         XCopyArea(dpy, tmp, pix, gc, 0, 0, width, iheight, 0, iheight*i);
  718.     }
  719.     XFreePixmap(dpy, tmp);
  720.     break;
  721.      case MSTYLE_SINGLE:
  722.     pix = renderTexture(scr, texture, width, iheight*4, NULL, MENU_BEVEL);
  723.     break;
  724.      case MSTYLE_FLAT:
  725.     pix = renderTexture(scr, texture, width, iheight*4, NULL, RBEV_RAISED2);
  726.     break;
  727.     }
  728.     XFreeGC(dpy, gc);
  729.  
  730.     return pix;
  731. }
  732.  
  733.  
  734. static void
  735. renderPreview(_Panel *panel, GC gc, int part, int relief)
  736. {
  737.     WMListItem *item;
  738.     TextureListItem *titem;
  739.     Pixmap pix;
  740.     WMScreen *scr = WMWidgetScreen(panel->frame);
  741.  
  742.     item = WMGetListItem(panel->texLs, panel->textureIndex[part]);
  743.     titem = (TextureListItem*)item->clientData;
  744.  
  745.     pix = renderTexture(scr, titem->prop, 
  746.             previewPositions[part].size.width,
  747.             previewPositions[part].size.height,
  748.             NULL, relief);
  749.  
  750.     XCopyArea(WMScreenDisplay(scr), pix, panel->preview, gc, 0, 0, 
  751.           previewPositions[part].size.width, 
  752.           previewPositions[part].size.height,
  753.           previewPositions[part].pos.x,
  754.           previewPositions[part].pos.y);
  755.  
  756.     XFreePixmap(WMScreenDisplay(scr), pix);
  757. }
  758.  
  759.  
  760. static void
  761. updatePreviewBox(_Panel *panel, int elements)
  762. {
  763.     WMScreen *scr = WMWidgetScreen(panel->win);
  764.     Display *dpy = WMScreenDisplay(scr);
  765.  /*   RContext *rc = WMScreenRContext(scr);*/
  766.     int refresh = 0;
  767.     Pixmap pix;
  768.     GC gc;
  769.     int colorUpdate = 0;
  770.     WMColor *black = WMBlackColor(scr);
  771.  
  772.     gc = XCreateGC(dpy, WMWidgetXID(panel->win), 0, NULL);
  773.  
  774.  
  775.     if (panel->preview == None) {
  776.     WMColor *color;
  777.  
  778.     panel->preview = XCreatePixmap(dpy, WMWidgetXID(panel->win),
  779.                        240-4, 215-4, WMScreenDepth(scr));
  780.  
  781.     color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
  782.     XFillRectangle(dpy, panel->preview, WMColorGC(color),
  783.                0, 0, 240-4, 215-4);
  784.     WMReleaseColor(color);
  785.  
  786.     refresh = -1;
  787.     }
  788.  
  789.  
  790.     if (elements & (1<<PFOCUSED)) {
  791.     renderPreview(panel, gc, PFOCUSED, RBEV_RAISED2);
  792.     XDrawRectangle(dpy, panel->preview, WMColorGC(black),
  793.                previewPositions[PFOCUSED].pos.x-1,
  794.                previewPositions[PFOCUSED].pos.y-1,
  795.                previewPositions[PFOCUSED].size.width,
  796.                previewPositions[PFOCUSED].size.height);
  797.     colorUpdate |= FTITLE_COL;
  798.     }
  799.     if (elements & (1<<PUNFOCUSED)) {
  800.     renderPreview(panel, gc, PUNFOCUSED, RBEV_RAISED2);
  801.     XDrawRectangle(dpy, panel->preview, WMColorGC(black),
  802.                previewPositions[PUNFOCUSED].pos.x-1,
  803.                previewPositions[PUNFOCUSED].pos.y-1,
  804.                previewPositions[PUNFOCUSED].size.width,
  805.                previewPositions[PUNFOCUSED].size.height);
  806.     colorUpdate |= UTITLE_COL;
  807.     }
  808.     if (elements & (1<<POWNER)) {
  809.     renderPreview(panel, gc, POWNER, RBEV_RAISED2);
  810.     XDrawRectangle(dpy, panel->preview, WMColorGC(black),
  811.                previewPositions[POWNER].pos.x-1,
  812.                previewPositions[POWNER].pos.y-1,
  813.                previewPositions[POWNER].size.width,
  814.                previewPositions[POWNER].size.height);
  815.     colorUpdate |= OTITLE_COL;
  816.     }
  817.     if (elements & (1<<PRESIZEBAR)) {
  818.     renderPreview(panel, gc, PRESIZEBAR, RESIZEBAR_BEVEL);
  819.     }
  820.     if (elements & (1<<PMTITLE)) {
  821.     renderPreview(panel, gc, PMTITLE, RBEV_RAISED2);
  822.     colorUpdate |= MTITLE_COL;
  823.     }
  824.     if (elements & (1<<PMITEM)) {
  825.     WMListItem *item;
  826.     TextureListItem *titem;
  827.  
  828.     item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
  829.     titem = (TextureListItem*)item->clientData;
  830.  
  831.     pix = renderMenu(panel, titem->prop,
  832.              previewPositions[PMITEM].size.width, 
  833.              previewPositions[PMITEM].size.height/4);
  834.  
  835.     XCopyArea(dpy, pix, panel->preview, gc, 0, 0,
  836.           previewPositions[PMITEM].size.width, 
  837.           previewPositions[PMITEM].size.height,
  838.           previewPositions[PMITEM].pos.x,
  839.           previewPositions[PMITEM].pos.y);
  840.  
  841.     XFreePixmap(dpy, pix);
  842.  
  843.     colorUpdate |= MITEM_COL|MDISAB_COL|MHIGH_COL|MHIGHT_COL;
  844.     }
  845.     if (elements & (1<<PMITEM|1<<PMTITLE)) {
  846.     XDrawLine(dpy, panel->preview, gc, 29, 120, 29, 120+20*4+20);
  847.     XDrawLine(dpy, panel->preview, gc, 29, 119, 119, 119);
  848.     }
  849.     if (elements & (1<<PICON)) {
  850.     WMListItem *item;
  851.     TextureListItem *titem;
  852.  
  853.     item = WMGetListItem(panel->texLs, panel->textureIndex[6]);
  854.     titem = (TextureListItem*)item->clientData;
  855.  
  856.     renderPreview(panel, gc, PICON,
  857.               titem->ispixmap ? 0 : RBEV_RAISED3);
  858.  
  859.     colorUpdate |= ICONT_COL|ICONB_COL|CLIP_COL|CCLIP_COL;
  860.     }
  861.     if (refresh < 0) {
  862.     WMPixmap *p;
  863.  
  864.     p = WMCreatePixmapFromXPixmaps(scr, panel->preview, None,
  865.                        240-4, 215-4, WMScreenDepth(scr));
  866.  
  867.     WMSetLabelImage(panel->prevL, p);
  868.     WMReleasePixmap(p);
  869.  
  870.     if (colorUpdate)
  871.         updateColorPreviewBox(panel, colorUpdate);
  872.     } else {
  873.     if (colorUpdate)
  874.         updateColorPreviewBox(panel, colorUpdate);
  875.     else
  876.         WMRedisplayWidget(panel->prevL);
  877.     }
  878.  
  879.     XFreeGC(dpy, gc);
  880.     WMReleaseColor(black);
  881. }
  882.  
  883.  
  884.  
  885.  
  886. static void
  887. cancelNewTexture(void *data)
  888. {
  889.     _Panel *panel = (_Panel*)data;
  890.     
  891.     HideTexturePanel(panel->texturePanel);
  892. }
  893.  
  894.  
  895.  
  896.  
  897. static char*
  898. makeFileName(char *prefix)
  899. {
  900.     char *fname;
  901.  
  902.     fname = wstrdup(prefix);
  903.  
  904.     while (access(fname, F_OK)==0) {
  905.     char buf[30];
  906.  
  907.     free(fname);
  908.     sprintf(buf, "%08lx.cache", time(NULL));
  909.     fname = wstrappend(prefix, buf);
  910.     }
  911.  
  912.     return fname;
  913. }
  914.  
  915.  
  916.  
  917.  
  918. static void
  919. okNewTexture(void *data)
  920. {
  921.     _Panel *panel = (_Panel*)data;
  922.     WMListItem *item;
  923.     char *name;
  924.     char *str;
  925.     proplist_t prop;
  926.     TextureListItem *titem;
  927.     WMScreen *scr = WMWidgetScreen(panel->win);
  928.  
  929.     titem = wmalloc(sizeof(TextureListItem));
  930.     memset(titem, 0, sizeof(TextureListItem));
  931.  
  932.     HideTexturePanel(panel->texturePanel);
  933.  
  934.     name = GetTexturePanelTextureName(panel->texturePanel);
  935.  
  936.     prop = GetTexturePanelTexture(panel->texturePanel);
  937.  
  938.     str = PLGetDescription(prop);
  939.  
  940.     titem->title = name;
  941.     titem->prop = prop;
  942.     titem->texture = str;
  943.     titem->selectedFor = 0;
  944.  
  945.     titem->ispixmap = isPixmap(prop);
  946.  
  947.     titem->path = makeFileName(panel->fprefix);
  948.     titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT,
  949.                    titem->path, 0);
  950.  
  951.     item = WMAddListItem(panel->texLs, "");
  952.     item->clientData = titem;
  953.  
  954.     WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
  955. }
  956.  
  957.  
  958. static void
  959. okEditTexture(void *data)
  960. {
  961.     _Panel *panel = (_Panel*)data;
  962.     WMListItem *item;
  963.     char *name;
  964.     char *str;
  965.     proplist_t prop;
  966.     TextureListItem *titem;
  967.  
  968.     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
  969.     titem = (TextureListItem*)item->clientData;
  970.  
  971.     HideTexturePanel(panel->texturePanel);
  972.  
  973.     if (titem->current) {
  974.     name = GetTexturePanelTextureName(panel->texturePanel);
  975.  
  976.     free(titem->title);
  977.     titem->title = name;
  978.     }
  979.  
  980.     prop = GetTexturePanelTexture(panel->texturePanel);
  981.  
  982.     str = PLGetDescription(prop);
  983.  
  984.     PLRelease(titem->prop);
  985.     titem->prop = prop;
  986.  
  987.     titem->ispixmap = isPixmap(prop);
  988.  
  989.     free(titem->texture);
  990.     titem->texture = str;
  991.  
  992.     XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
  993.     titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
  994.                    TEXPREV_WIDTH, TEXPREV_HEIGHT,
  995.                    titem->path, 0);
  996.  
  997.     WMRedisplayWidget(panel->texLs);
  998.  
  999.     if (titem->selectedFor)
  1000.     updatePreviewBox(panel, titem->selectedFor);
  1001.  
  1002.     changePage(panel->secP, panel);
  1003. }
  1004.  
  1005.  
  1006.  
  1007. static void
  1008. editTexture(WMWidget *w, void *data)
  1009. {
  1010.     _Panel *panel = (_Panel*)data;
  1011.     WMListItem *item;
  1012.     TextureListItem *titem;
  1013.  
  1014.     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
  1015.     titem = (TextureListItem*)item->clientData;
  1016.  
  1017.     SetTexturePanelPixmapPath(panel->texturePanel,
  1018.                   GetObjectForKey("PixmapPath"));
  1019.  
  1020.     SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
  1021.  
  1022.     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
  1023.     SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
  1024.  
  1025.     ShowTexturePanel(panel->texturePanel);
  1026. }
  1027.  
  1028.  
  1029.  
  1030. static void
  1031. newTexture(WMWidget *w, void *data)
  1032. {
  1033.     _Panel *panel = (_Panel*)data;
  1034.  
  1035.     SetTexturePanelPixmapPath(panel->texturePanel,
  1036.                   GetObjectForKey("PixmapPath"));
  1037.  
  1038.     SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
  1039.  
  1040.     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
  1041.  
  1042.     SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
  1043.  
  1044.     ShowTexturePanel(panel->texturePanel);
  1045. }
  1046.  
  1047.  
  1048.  
  1049. static void
  1050. deleteTexture(WMWidget *w, void *data)
  1051. {
  1052.     _Panel *panel = (_Panel*)data;
  1053.     WMListItem *item;
  1054.     TextureListItem *titem;
  1055.     int row;
  1056.     int section;
  1057.  
  1058.     section = WMGetPopUpButtonSelectedItem(panel->secP);
  1059.     row = WMGetListSelectedItemRow(panel->texLs);
  1060.     item = WMGetListItem(panel->texLs, row);
  1061.     titem = (TextureListItem*)item->clientData;
  1062.  
  1063.     if (titem->selectedFor & (1 << section)) {
  1064.     TextureListItem *titem2;
  1065.  
  1066.     panel->textureIndex[section] = section;
  1067.     item = WMGetListItem(panel->texLs, section);
  1068.     titem2 = (TextureListItem*)item->clientData;
  1069.     titem2->selectedFor |= 1 << section;
  1070.     }
  1071.  
  1072.     free(titem->title);
  1073.     free(titem->texture);
  1074.     PLRelease(titem->prop);
  1075.     if (titem->path) {
  1076.     if (remove(titem->path) < 0 && errno != ENOENT) {
  1077.         wsyserror("could not remove file %s", titem->path);
  1078.     }
  1079.     free(titem->path);
  1080.     }
  1081.  
  1082.     free(titem);
  1083.  
  1084.     WMRemoveListItem(panel->texLs, row);
  1085.     WMSetButtonEnabled(panel->delB, False);
  1086. }
  1087.  
  1088.  
  1089.  
  1090.  
  1091. static void
  1092. extractTexture(WMWidget *w, void *data)
  1093. {
  1094.     _Panel *panel = (_Panel*)data;
  1095.     char *path;
  1096.     WMOpenPanel *opanel;
  1097.     WMScreen *scr = WMWidgetScreen(w);
  1098.  
  1099.     opanel = WMGetOpenPanel(scr);
  1100.     WMSetFilePanelCanChooseDirectories(opanel, False);
  1101.     WMSetFilePanelCanChooseFiles(opanel, True);
  1102.  
  1103.     if (WMRunModalFilePanelForDirectory(opanel, panel->win, wgethomedir(),
  1104.                     _("Select File"), NULL)) {
  1105.     path = WMGetFilePanelFileName(opanel);
  1106.  
  1107.     OpenExtractPanelFor(panel, path);
  1108.  
  1109.     free(path);
  1110.     }
  1111. }
  1112.  
  1113.  
  1114. static void
  1115. changePage(WMWidget *w, void *data)
  1116. {
  1117.     _Panel *panel = (_Panel*)data;
  1118.     int section;
  1119.     WMListItem *item;
  1120.     TextureListItem *titem;
  1121.     WMScreen *scr = WMWidgetScreen(panel->frame);
  1122.     RContext *rc = WMScreenRContext(scr);
  1123.     static WMPoint positions[] = {
  1124.     {5, 10},
  1125.     {5, 40},
  1126.     {5, 70},
  1127.     {5, 100},
  1128.     {5, 120},
  1129.     {5, 160},
  1130.     {130, 150}
  1131.     };
  1132.  
  1133.     if (w) {
  1134.     section = WMGetPopUpButtonSelectedItem(panel->secP);
  1135.  
  1136.     WMSelectListItem(panel->texLs, panel->textureIndex[section]);
  1137.  
  1138.     WMSetListPosition(panel->texLs, panel->textureIndex[section] - 2);
  1139.  
  1140.     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
  1141.  
  1142.     titem = (TextureListItem*)item->clientData;
  1143.     }
  1144.     {
  1145.     WMColor *color;
  1146.  
  1147.     color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
  1148.     XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
  1149.                positions[panel->oldsection].x, 
  1150.                positions[panel->oldsection].y, 22, 22);
  1151.     WMReleaseColor(color);
  1152.     }
  1153.     if (w) {
  1154.     panel->oldsection = section;
  1155.     WMDrawPixmap(panel->hand, panel->preview, positions[section].x, 
  1156.              positions[section].y);
  1157.     }
  1158.     WMRedisplayWidget(panel->prevL);
  1159. }
  1160.  
  1161.  
  1162.  
  1163. static void
  1164. previewClick(XEvent *event, void *clientData)
  1165. {
  1166.     _Panel *panel = (_Panel*)clientData;
  1167.     int i;
  1168.  
  1169.     switch (panel->oldTabItem) {
  1170.      case 0:
  1171.     for (i = 0; i < sizeof(previewPositions)/sizeof(WMRect); i++) {
  1172.         if (event->xbutton.x >= previewPositions[i].pos.x
  1173.         && event->xbutton.y >= previewPositions[i].pos.y
  1174.         && event->xbutton.x < previewPositions[i].pos.x 
  1175.         + previewPositions[i].size.width
  1176.         && event->xbutton.y < previewPositions[i].pos.y 
  1177.         + previewPositions[i].size.height) {
  1178.         
  1179.         WMSetPopUpButtonSelectedItem(panel->secP, i);
  1180.         changePage(panel->secP, panel);
  1181.         return;
  1182.         }
  1183.     }
  1184.     break;
  1185.      case 1:
  1186.     for (i = 0; i < WMGetPopUpButtonNumberOfItems(panel->colP); i++) {
  1187.         if (event->xbutton.x >= previewColorPositions[i].pos.x
  1188.         && event->xbutton.y >= previewColorPositions[i].pos.y
  1189.         && event->xbutton.x < previewColorPositions[i].pos.x 
  1190.         + previewColorPositions[i].size.width
  1191.         && event->xbutton.y < previewColorPositions[i].pos.y 
  1192.         + previewColorPositions[i].size.height) {
  1193.         
  1194.         /* yuck kluge */
  1195.         if (i == 7)
  1196.             i = 4;
  1197.         
  1198.         WMSetPopUpButtonSelectedItem(panel->colP, i);
  1199.         changeColorPage(panel->colP, panel);
  1200.         return;
  1201.         }
  1202.     }
  1203.     break;
  1204.     }
  1205. }
  1206.  
  1207.  
  1208. static void
  1209. textureClick(WMWidget *w, void *data)
  1210. {
  1211.     _Panel *panel = (_Panel*)data;
  1212.     int i;
  1213.     WMListItem *item;
  1214.     TextureListItem *titem;
  1215.  
  1216.     i = WMGetListSelectedItemRow(panel->texLs);
  1217.  
  1218.     item = WMGetListItem(panel->texLs, i);
  1219.  
  1220.     titem = (TextureListItem*)item->clientData;
  1221.  
  1222.     if (titem->current) {
  1223.     WMSetButtonEnabled(panel->delB, False);
  1224.     } else {
  1225.     WMSetButtonEnabled(panel->delB, True);
  1226.     }
  1227. }
  1228.  
  1229.  
  1230.  
  1231. static void
  1232. textureDoubleClick(WMWidget *w, void *data)
  1233. {
  1234.     _Panel *panel = (_Panel*)data;
  1235.     int i, section;
  1236.     WMListItem *item;
  1237.     TextureListItem *titem;
  1238.  
  1239.     /* unselect old texture */
  1240.     section = WMGetPopUpButtonSelectedItem(panel->secP);
  1241.  
  1242.     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
  1243.     titem = (TextureListItem*)item->clientData;
  1244.     titem->selectedFor &= ~(1 << section);
  1245.  
  1246.     /* select new texture */
  1247.     i = WMGetListSelectedItemRow(panel->texLs);
  1248.  
  1249.     item = WMGetListItem(panel->texLs, i);
  1250.  
  1251.     titem = (TextureListItem*)item->clientData;
  1252.  
  1253.     titem->selectedFor |= 1<<section;
  1254.  
  1255.     panel->textureIndex[section] = i;
  1256.  
  1257.     WMRedisplayWidget(panel->texLs);
  1258.  
  1259.     updatePreviewBox(panel, 1<<section);
  1260. }
  1261.  
  1262.  
  1263.  
  1264. static void
  1265. paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state, 
  1266.           WMRect *rect)
  1267. {
  1268.     _Panel *panel = (_Panel*)WMGetHangedData(lPtr);
  1269.     WMScreen *scr = WMWidgetScreen(lPtr);
  1270.     int width, height, x, y;
  1271.     Display *dpy = WMScreenDisplay(scr);
  1272.     WMColor *white = WMWhiteColor(scr);
  1273.     WMListItem *item;
  1274.     WMColor *black = WMBlackColor(scr);
  1275.     TextureListItem *titem;
  1276.  
  1277.     item = WMGetListItem(lPtr, index);
  1278.     titem = (TextureListItem*)item->clientData;
  1279.     if (!titem) {
  1280.     WMReleaseColor(white);
  1281.     WMReleaseColor(black);
  1282.     return;
  1283.     }
  1284.  
  1285.     width = rect->size.width;
  1286.     height = rect->size.height;
  1287.     x = rect->pos.x;
  1288.     y = rect->pos.y;
  1289.  
  1290.     if (state & WLDSSelected)
  1291.         XFillRectangle(dpy, d, WMColorGC(white), x, y, width, height);
  1292.     else
  1293.         XClearArea(dpy, d, x, y, width, height, False);
  1294.  
  1295.  
  1296.     if (titem->preview)
  1297.     XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0, 
  1298.           TEXPREV_WIDTH, TEXPREV_HEIGHT, x + 5, y + 5);
  1299.     
  1300.     if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
  1301.     WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
  1302.     else if (titem->selectedFor)
  1303.     WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
  1304.  
  1305.     WMDrawString(scr, d, WMColorGC(black), panel->boldFont,
  1306.          x + TEXPREV_WIDTH + 22, y + 2, titem->title, 
  1307.          strlen(titem->title));
  1308.  
  1309.     WMDrawString(scr, d, WMColorGC(black), panel->smallFont,
  1310.          x + TEXPREV_WIDTH + 14, y + 18, titem->texture, 
  1311.          strlen(titem->texture));
  1312.  
  1313.  
  1314.     WMReleaseColor(white);
  1315.     WMReleaseColor(black);
  1316. }
  1317.  
  1318.  
  1319.  
  1320. static Pixmap
  1321. loadRImage(WMScreen *scr, char *path)
  1322. {
  1323.     FILE *f;
  1324.     RImage *image;
  1325.     int w, h, d;
  1326.     Pixmap pixmap;
  1327.  
  1328.     f = fopen(path, "r");
  1329.     if (!f)
  1330.     return None;
  1331.  
  1332.     fscanf(f, "%02x%02x%1x", &w, &h, &d);
  1333.  
  1334.     image = RCreateImage(w, h, d == 4);
  1335.     fread(image->data, 1, w*h*d, f);
  1336.     fclose(f);
  1337.  
  1338.     RConvertImage(WMScreenRContext(scr), image, &pixmap);
  1339.     RDestroyImage(image);
  1340.  
  1341.     return pixmap;
  1342. }
  1343.  
  1344.  
  1345.  
  1346. static void
  1347. fillTextureList(WMList *lPtr)
  1348. {
  1349.     proplist_t textureList;
  1350.     proplist_t texture;
  1351.     WMUserDefaults *udb = WMGetStandardUserDefaults();
  1352.     TextureListItem *titem;
  1353.     WMScreen *scr  = WMWidgetScreen(lPtr);
  1354.     int i;
  1355.  
  1356.     textureList = WMGetUDObjectForKey(udb, "TextureList");
  1357.     if (!textureList)
  1358.     return;
  1359.  
  1360.     for (i = 0; i < PLGetNumberOfElements(textureList); i++) {
  1361.     WMListItem *item;
  1362.  
  1363.     texture = PLGetArrayElement(textureList, i);
  1364.  
  1365.     titem = wmalloc(sizeof(TextureListItem));
  1366.     memset(titem, 0, sizeof(TextureListItem));
  1367.  
  1368.     titem->title = wstrdup(PLGetString(PLGetArrayElement(texture, 0)));
  1369.     titem->prop = PLRetain(PLGetArrayElement(texture, 1));
  1370.     titem->texture = PLGetDescription(titem->prop);
  1371.     titem->selectedFor = 0;
  1372.     titem->path = wstrdup(PLGetString(PLGetArrayElement(texture, 2)));
  1373.  
  1374.     titem->preview = loadRImage(scr, titem->path);
  1375.     if (!titem->preview) {
  1376.         titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH, 
  1377.                        TEXPREV_HEIGHT, NULL, 0);
  1378.     }
  1379.     item = WMAddListItem(lPtr, "");
  1380.     item->clientData = titem;
  1381.     }
  1382. }
  1383.  
  1384.  
  1385. static void
  1386. fillColorList(_Panel *panel)
  1387. {
  1388.     WMColor *color;
  1389.     proplist_t list;
  1390.     WMUserDefaults *udb = WMGetStandardUserDefaults();
  1391.     WMScreen *scr = WMWidgetScreen(panel->frame);
  1392.     int i;
  1393.     
  1394.     list = WMGetUDObjectForKey(udb, "ColorList");
  1395.     if (!list) {
  1396.     for (i = 0; i < 24; i++) {
  1397.         color = WMCreateNamedColor(scr, sampleColors[i], False);
  1398.         if (!color)
  1399.         continue;
  1400.         WMSetColorWellColor(panel->sampW[i], color);
  1401.         WMReleaseColor(color);
  1402.     }
  1403.     } else {
  1404.     proplist_t c;
  1405.  
  1406.     for (i = 0; i < WMIN(24, PLGetNumberOfElements(list)); i++) {
  1407.         c = PLGetArrayElement(list, i);
  1408.         if (!c || !PLIsString(c))
  1409.         continue;
  1410.         color = WMCreateNamedColor(scr, PLGetString(c), False);
  1411.         if (!color)
  1412.         continue;
  1413.         WMSetColorWellColor(panel->sampW[i], color);
  1414.         WMReleaseColor(color);
  1415.     }
  1416.     }
  1417. }
  1418.  
  1419.  
  1420. /*************************************************************************/
  1421.  
  1422.  
  1423. static void
  1424. changeColorPage(WMWidget *w, void *data)
  1425. {
  1426.     _Panel *panel = (_Panel*)data;
  1427.     int section;
  1428.     WMScreen *scr = WMWidgetScreen(panel->frame);
  1429.     RContext *rc = WMScreenRContext(scr);
  1430.     static WMPoint positions[] = {
  1431.     {5, 10},
  1432.     {5, 40},
  1433.     {5, 70},
  1434.     {5, 120},
  1435.     {5, 140},
  1436.     {5, 160},
  1437.     {5, 180},
  1438.     {5, 180},
  1439.     {130, 140},
  1440.     {130, 140},
  1441.     {130, 140},
  1442.     {130, 140}
  1443.     };
  1444.  
  1445.     if (panel->preview) {
  1446.     WMColor *color;
  1447.  
  1448.     color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
  1449.     XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
  1450.                positions[panel->oldcsection].x, 
  1451.                positions[panel->oldcsection].y, 22, 22);
  1452.     WMReleaseColor(color);
  1453.     }
  1454.     if (w) {
  1455.     section = WMGetPopUpButtonSelectedItem(panel->colP);
  1456.  
  1457.     panel->oldcsection = section;
  1458.     if (panel->preview)
  1459.         WMDrawPixmap(panel->hand, panel->preview, positions[section].x, 
  1460.              positions[section].y);
  1461.  
  1462.     section = WMGetPopUpButtonSelectedItem(panel->colP);
  1463.  
  1464.     WMSetColorWellColor(panel->colW, panel->colors[section]);
  1465.     }
  1466.     WMRedisplayWidget(panel->prevL);
  1467. }
  1468.  
  1469.  
  1470. static void
  1471. paintText(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
  1472.       int x, int y, int w, int h, WMAlignment align, char *text)
  1473. {
  1474.     int l = strlen(text);
  1475.  
  1476.     switch (align) {
  1477.      case WALeft:
  1478.     x += 5;
  1479.     break;
  1480.      case WARight:
  1481.     x += w - 5 - WMWidthOfString(font, text, l);
  1482.     break;
  1483.      default:
  1484.      case WACenter:
  1485.     x += (w - WMWidthOfString(font, text, l))/2;
  1486.     break;
  1487.     }
  1488.     WMDrawString(scr, d, WMColorGC(color), font, x,
  1489.          y + (h - WMFontHeight(font))/2, text, l);
  1490. }
  1491.  
  1492.  
  1493.  
  1494. static void
  1495. updateColorPreviewBox(_Panel *panel, int elements)
  1496. {
  1497.     WMScreen *scr = WMWidgetScreen(panel->frame);
  1498.     WMPixmap *pixmap;
  1499.     Pixmap d;
  1500.  
  1501.     pixmap = WMGetLabelImage(panel->prevL);
  1502.     d = WMGetPixmapXID(pixmap);
  1503.  
  1504.     if (elements & FTITLE_COL) {
  1505.     paintText(scr, d, panel->colors[0], panel->boldFont, 30, 10, 190, 20,
  1506.           panel->titleAlignment, _("Focused Window"));
  1507.     }
  1508.     if (elements & UTITLE_COL) {
  1509.     paintText(scr, d, panel->colors[1], panel->boldFont, 30, 40, 190, 20,
  1510.           panel->titleAlignment, _("Unfocused Window"));
  1511.     }
  1512.     if (elements & OTITLE_COL) {
  1513.     paintText(scr, d, panel->colors[2], panel->boldFont, 30, 70, 190, 20,
  1514.           panel->titleAlignment, _("Owner of Focused Window"));
  1515.     }
  1516.     if (elements & MTITLE_COL) {
  1517.     paintText(scr, d, panel->colors[3], panel->boldFont, 30, 120, 90, 20,
  1518.           WALeft, _("Menu Title"));
  1519.     }
  1520.     if (elements & MITEM_COL) {
  1521.     paintText(scr, d, panel->colors[4], panel->normalFont, 30, 140, 90, 20,
  1522.           WALeft, _("Normal Item"));
  1523.     paintText(scr, d, panel->colors[4], panel->normalFont, 30, 200, 90, 20,
  1524.           WALeft, _("Normal Item"));
  1525.     }
  1526.     if (elements & MDISAB_COL) {
  1527.     paintText(scr, d, panel->colors[5], panel->normalFont, 30, 160, 90, 20,
  1528.           WALeft, _("Disabled Item"));
  1529.     }
  1530.     if (elements & MHIGH_COL) {
  1531.     XFillRectangle(WMScreenDisplay(scr), d, WMColorGC(panel->colors[6]),
  1532.                31, 181, 87, 17);
  1533.     elements |= MHIGHT_COL;
  1534.     }
  1535.     if (elements & MHIGHT_COL) {
  1536.     paintText(scr, d, panel->colors[7], panel->normalFont, 30, 180, 90, 20,
  1537.           WALeft, _("Highlighted"));
  1538.     }
  1539. /*
  1540.     if (elements & ICONT_COL) {
  1541.     WRITE(_("Focused Window"), panel->colors[8], panel->boldFont, 
  1542.           155, 130, 64);
  1543.     }
  1544.     if (elements & ICONB_COL) {
  1545.     WRITE(_("Focused Window"), panel->colors[9], panel->boldFont, 
  1546.           0, 0, 30);
  1547.     }
  1548.     if (elements & CLIP_COL) {
  1549.     WRITE(_("Focused Window"), panel->colors[10], panel->boldFont, 
  1550.           0, 0, 30);
  1551.     }
  1552.     if (elements & CCLIP_COL) {
  1553.     WRITE(_("Focused Window"), panel->colors[11], panel->boldFont, 
  1554.           0, 0, 30);
  1555.     }
  1556.  */
  1557.     WMRedisplayWidget(panel->prevL);
  1558. }
  1559.  
  1560.  
  1561. static void
  1562. colorWellObserver(void *self, WMNotification *n)
  1563. {
  1564.     _Panel *panel = (_Panel*)self;
  1565.     int p;
  1566.  
  1567.     p = WMGetPopUpButtonSelectedItem(panel->colP);
  1568.  
  1569.     WMReleaseColor(panel->colors[p]);
  1570.  
  1571.     panel->colors[p] = WMRetainColor(WMGetColorWellColor(panel->colW));
  1572.  
  1573.     updateColorPreviewBox(panel, 1<<p);
  1574. }
  1575.  
  1576.  
  1577. static void
  1578. changedTabItem(struct WMTabViewDelegate *self, WMTabView *tabView,
  1579.            WMTabViewItem *item)
  1580. {
  1581.     _Panel *panel = self->data;
  1582.     int i;
  1583.  
  1584.     i = WMGetTabViewItemIdentifier(item); 
  1585.     switch (i) {
  1586.      case 0:
  1587.     switch (panel->oldTabItem) {
  1588.      case 1:
  1589.         changeColorPage(NULL, panel);
  1590.         break;
  1591.     }
  1592.     changePage(panel->secP, panel);
  1593.     break;
  1594.      case 1:
  1595.     switch (panel->oldTabItem) {
  1596.      case 0:
  1597.         changePage(NULL, panel);
  1598.         break;        
  1599.     }
  1600.     changeColorPage(panel->colP, panel);
  1601.     break;
  1602.      case 2:
  1603.     switch (panel->oldTabItem) {
  1604.      case 0:
  1605.         changePage(NULL, panel);
  1606.         break;
  1607.      case 1:
  1608.         changeColorPage(NULL, panel);
  1609.         break;
  1610.     }
  1611.     break;
  1612.     }
  1613.  
  1614.     panel->oldTabItem = i;
  1615. }
  1616.  
  1617.  
  1618. /*************************************************************************/
  1619.  
  1620. static void
  1621. menuStyleCallback(WMWidget *self, void *data)
  1622. {
  1623.     _Panel *panel = (_Panel*)data;
  1624.  
  1625.     if (self == panel->mstyB[0]) {
  1626.     panel->menuStyle = MSTYLE_NORMAL;
  1627.     updatePreviewBox(panel, 1<<PMITEM);
  1628.  
  1629.     } else if (self == panel->mstyB[1]) {
  1630.     panel->menuStyle = MSTYLE_SINGLE;
  1631.     updatePreviewBox(panel, 1<<PMITEM);
  1632.  
  1633.     } else if (self == panel->mstyB[2]) {
  1634.     panel->menuStyle = MSTYLE_FLAT;
  1635.     updatePreviewBox(panel, 1<<PMITEM);
  1636.     }
  1637. }
  1638.  
  1639.  
  1640. static void
  1641. titleAlignCallback(WMWidget *self, void *data)
  1642. {
  1643.     _Panel *panel = (_Panel*)data;
  1644.  
  1645.     if (self == panel->taliB[0]) {
  1646.     panel->titleAlignment = WALeft;
  1647.     updatePreviewBox(panel, 1<<PFOCUSED|1<<PUNFOCUSED|1<<POWNER);
  1648.  
  1649.     } else if (self == panel->taliB[1]) {
  1650.     panel->titleAlignment = WACenter;
  1651.     updatePreviewBox(panel, 1<<PFOCUSED|1<<PUNFOCUSED|1<<POWNER);
  1652.  
  1653.     } else if (self == panel->taliB[2]) {
  1654.     panel->titleAlignment = WARight;
  1655.     updatePreviewBox(panel, 1<<PFOCUSED|1<<PUNFOCUSED|1<<POWNER);
  1656.     }
  1657. }
  1658.  
  1659.  
  1660. static void
  1661. createPanel(Panel *p)
  1662. {
  1663.     _Panel *panel = (_Panel*)p;
  1664.     WMFont *font;
  1665.     WMScreen *scr = WMWidgetScreen(panel->win);
  1666.     WMTabViewItem *item;
  1667.     int i;
  1668.     char *tmp;
  1669.     Bool ok = True;
  1670.     
  1671.     panel->fprefix = wstrappend(wusergnusteppath(), "/.AppInfo");
  1672.  
  1673.     if (access(panel->fprefix, F_OK)!=0) {
  1674.     if (mkdir(panel->fprefix, 0755) < 0) {
  1675.         wsyserror(panel->fprefix);
  1676.         ok = False;
  1677.     }
  1678.     }
  1679.     if (ok) {
  1680.     tmp = wstrappend(panel->fprefix, "/WPrefs/");
  1681.     free(panel->fprefix);
  1682.     panel->fprefix = tmp;
  1683.     if (access(panel->fprefix, F_OK)!=0) {
  1684.         if (mkdir(panel->fprefix, 0755) < 0) {
  1685.         wsyserror(panel->fprefix);
  1686.         }
  1687.     }
  1688.     }
  1689.  
  1690.     panel->smallFont = WMSystemFontOfSize(scr, 10);
  1691.     panel->normalFont = WMSystemFontOfSize(scr, 12);
  1692.     panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
  1693.  
  1694.     panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
  1695.     panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
  1696.     panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
  1697.  
  1698.     panel->frame = WMCreateFrame(panel->win);
  1699.     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
  1700.     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
  1701.  
  1702.     /* preview box */
  1703.     panel->prevL = WMCreateLabel(panel->frame);
  1704.     WMResizeWidget(panel->prevL, 240, FRAME_HEIGHT - 20);
  1705.     WMMoveWidget(panel->prevL, 15, 10);
  1706.     WMSetLabelRelief(panel->prevL, WRSunken);
  1707.     WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
  1708.     
  1709.     WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask,
  1710.              previewClick, panel);
  1711.     
  1712.  
  1713.     /* tabview */
  1714.  
  1715.     tabviewDelegate.data = panel;
  1716.  
  1717.     panel->tabv = WMCreateTabView(panel->frame);
  1718.     WMResizeWidget(panel->tabv, 245, FRAME_HEIGHT - 20);
  1719.     WMMoveWidget(panel->tabv, 265, 10);
  1720.     WMSetTabViewDelegate(panel->tabv, &tabviewDelegate);
  1721.  
  1722.     /*** texture list ***/
  1723.  
  1724.     panel->texF = WMCreateFrame(panel->frame);
  1725.     WMSetFrameRelief(panel->texF, WRFlat);
  1726.  
  1727.     item = WMCreateTabViewItemWithIdentifier(0);
  1728.     WMSetTabViewItemView(item, WMWidgetView(panel->texF));
  1729.     WMSetTabViewItemLabel(item, _("Texture"));
  1730.  
  1731.     WMAddItemInTabView(panel->tabv, item);
  1732.  
  1733.  
  1734.     panel->secP = WMCreatePopUpButton(panel->texF);
  1735.     WMResizeWidget(panel->secP, 228, 20);
  1736.     WMMoveWidget(panel->secP, 7, 7);
  1737.     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
  1738.     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
  1739.     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
  1740.     WMAddPopUpButtonItem(panel->secP, _("Window Resizebar"));
  1741.     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
  1742.     WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
  1743.     WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
  1744. /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
  1745.  */
  1746.     WMSetPopUpButtonSelectedItem(panel->secP, 0);
  1747.     WMSetPopUpButtonAction(panel->secP, changePage, panel);
  1748.  
  1749.     panel->texLs = WMCreateList(panel->texF);
  1750.     WMResizeWidget(panel->texLs, 165, 155);
  1751.     WMMoveWidget(panel->texLs, 70, 33);
  1752.     WMSetListUserDrawItemHeight(panel->texLs, 35);
  1753.     WMSetListUserDrawProc(panel->texLs, paintListItem);
  1754.     WMHangData(panel->texLs, panel);
  1755.     WMSetListAction(panel->texLs, textureClick, panel);
  1756.     WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
  1757.  
  1758.     WMSetBalloonTextForView(_("Double click in the texture you want to use\n"
  1759.                   "for the selected item."),
  1760.                 WMWidgetView(panel->texLs));
  1761.  
  1762.     /* command buttons */
  1763.  
  1764.     font = WMSystemFontOfSize(scr, 10);
  1765.  
  1766.  
  1767.     panel->newB = WMCreateCommandButton(panel->texF);
  1768.     WMResizeWidget(panel->newB, 57, 39);
  1769.     WMMoveWidget(panel->newB, 7, 33);
  1770.     WMSetButtonFont(panel->newB, font);
  1771.     WMSetButtonImagePosition(panel->newB, WIPAbove);
  1772.     WMSetButtonText(panel->newB, _("New"));
  1773.     WMSetButtonAction(panel->newB, newTexture, panel);
  1774.     SetButtonAlphaImage(scr, panel->newB, TNEW_FILE);
  1775.  
  1776.     WMSetBalloonTextForView(_("Create a new texture."),
  1777.                 WMWidgetView(panel->newB));
  1778.  
  1779.     panel->ripB = WMCreateCommandButton(panel->texF);
  1780.     WMResizeWidget(panel->ripB, 57, 39);
  1781.     WMMoveWidget(panel->ripB, 7, 72);
  1782.     WMSetButtonFont(panel->ripB, font);
  1783.     WMSetButtonImagePosition(panel->ripB, WIPAbove);
  1784.     WMSetButtonText(panel->ripB, _("Extract..."));
  1785.     WMSetButtonAction(panel->ripB, extractTexture, panel);
  1786.     SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE);
  1787.  
  1788.     WMSetBalloonTextForView(_("Extract texture(s) from a theme or a style file."),
  1789.                 WMWidgetView(panel->ripB));
  1790.  
  1791.     WMSetButtonEnabled(panel->ripB, False);
  1792.  
  1793.     panel->editB = WMCreateCommandButton(panel->texF);
  1794.     WMResizeWidget(panel->editB, 57, 39);
  1795.     WMMoveWidget(panel->editB, 7, 111);
  1796.     WMSetButtonFont(panel->editB, font);
  1797.     WMSetButtonImagePosition(panel->editB, WIPAbove);
  1798.     WMSetButtonText(panel->editB, _("Edit"));
  1799.     SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE);
  1800.     WMSetButtonAction(panel->editB, editTexture, panel);
  1801.     WMSetBalloonTextForView(_("Edit the highlighted texture."),
  1802.                 WMWidgetView(panel->editB));
  1803.  
  1804.     panel->delB = WMCreateCommandButton(panel->texF);
  1805.     WMResizeWidget(panel->delB, 57, 38);
  1806.     WMMoveWidget(panel->delB, 7, 150);
  1807.     WMSetButtonFont(panel->delB, font);
  1808.     WMSetButtonImagePosition(panel->delB, WIPAbove);
  1809.     WMSetButtonText(panel->delB, _("Delete"));
  1810.     SetButtonAlphaImage(scr, panel->delB, TDEL_FILE);
  1811.     WMSetButtonEnabled(panel->delB, False);
  1812.     WMSetButtonAction(panel->delB, deleteTexture, panel);
  1813.     WMSetBalloonTextForView(_("Delete the highlighted texture."),
  1814.                 WMWidgetView(panel->delB));
  1815.  
  1816.     WMReleaseFont(font);
  1817.  
  1818.     WMMapSubwidgets(panel->texF);
  1819.  
  1820.     /*** colors ***/
  1821.     panel->colF = WMCreateFrame(panel->frame);
  1822.     WMSetFrameRelief(panel->colF, WRFlat);
  1823.  
  1824.     item = WMCreateTabViewItemWithIdentifier(1);
  1825.     WMSetTabViewItemView(item, WMWidgetView(panel->colF));
  1826.     WMSetTabViewItemLabel(item, _("Color"));
  1827.  
  1828.     WMAddItemInTabView(panel->tabv, item);
  1829.  
  1830.     panel->colP = WMCreatePopUpButton(panel->colF);
  1831.     WMResizeWidget(panel->colP, 228, 20);
  1832.     WMMoveWidget(panel->colP, 7, 7);
  1833.     WMAddPopUpButtonItem(panel->colP, _("Focused Window Title"));
  1834.     WMAddPopUpButtonItem(panel->colP, _("Unfocused Window Title"));
  1835.     WMAddPopUpButtonItem(panel->colP, _("Owner of Focused Window Title"));
  1836.     WMAddPopUpButtonItem(panel->colP, _("Menu Title"));
  1837.     WMAddPopUpButtonItem(panel->colP, _("Menu Item Text"));
  1838.     WMAddPopUpButtonItem(panel->colP, _("Disabled Menu Item Text"));
  1839.     WMAddPopUpButtonItem(panel->colP, _("Menu Highlight Color"));
  1840.     WMAddPopUpButtonItem(panel->colP, _("Highlighted Menu Text Color"));
  1841.     /*
  1842.     WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title"));
  1843.     WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title Back"));
  1844.     WMAddPopUpButtonItem(panel->colP, _("Clip Title"));
  1845.     WMAddPopUpButtonItem(panel->colP, _("Collapsed Clip Title"));
  1846.      */
  1847.  
  1848.     WMSetPopUpButtonSelectedItem(panel->colP, 0);
  1849.  
  1850.     WMSetPopUpButtonAction(panel->colP, changeColorPage, panel);
  1851.  
  1852.  
  1853.     panel->colW = WMCreateColorWell(panel->colF);
  1854.     WMResizeWidget(panel->colW, 65, 50);
  1855.     WMMoveWidget(panel->colW, 30, 75);
  1856.     WMAddNotificationObserver(colorWellObserver, panel,
  1857.                   WMColorWellDidChangeNotification, panel->colW);
  1858.  
  1859.     for (i = 0; i < 4; i++) {
  1860.     int j;
  1861.     for (j = 0; j < 6; j++) {
  1862.         panel->sampW[i+j*4] = WMCreateColorWell(panel->colF);
  1863.         WMResizeWidget(panel->sampW[i+j*4], 22, 22);
  1864.         WMMoveWidget(panel->sampW[i+j*4], 130 + i*22, 40 + j*22);
  1865.         WSetColorWellBordered(panel->sampW[i+j*4], False);
  1866.     }
  1867.     }
  1868.  
  1869.     WMMapSubwidgets(panel->colF);
  1870.  
  1871.     /*** options ***/
  1872.     panel->optF = WMCreateFrame(panel->frame);
  1873.     WMSetFrameRelief(panel->optF, WRFlat);
  1874.  
  1875.     item = WMCreateTabViewItemWithIdentifier(2);
  1876.     WMSetTabViewItemView(item, WMWidgetView(panel->optF));
  1877.     WMSetTabViewItemLabel(item, _("Options"));
  1878.  
  1879.     WMAddItemInTabView(panel->tabv, item);
  1880.  
  1881.     panel->mstyF = WMCreateFrame(panel->optF);
  1882.     WMResizeWidget(panel->mstyF, 215, 85);
  1883.     WMMoveWidget(panel->mstyF, 15, 10);
  1884.     WMSetFrameTitle(panel->mstyF, _("Menu Style"));
  1885.  
  1886.     for (i = 0; i < 3; i++) {
  1887.     WMPixmap *icon;
  1888.     char *path;
  1889.  
  1890.     panel->mstyB[i] = WMCreateButton(panel->mstyF, WBTOnOff);
  1891.     WMResizeWidget(panel->mstyB[i], 54, 54);
  1892.     WMMoveWidget(panel->mstyB[i], 15 + i*65, 20);
  1893.     WMSetButtonImagePosition(panel->mstyB[i], WIPImageOnly);
  1894.     WMSetButtonAction(panel->mstyB[i], menuStyleCallback, panel);
  1895.     switch (i) {
  1896.      case 0:
  1897.         path = LocateImage(MSTYLE1_FILE);
  1898.         break;
  1899.      case 1:
  1900.         path = LocateImage(MSTYLE2_FILE);
  1901.         break;
  1902.      case 2:
  1903.         path = LocateImage(MSTYLE3_FILE);
  1904.         break;
  1905.     }
  1906.     if (path) {
  1907.         icon = WMCreatePixmapFromFile(scr, path);
  1908.         if (icon) {
  1909.         WMSetButtonImage(panel->mstyB[i], icon);
  1910.         WMReleasePixmap(icon);
  1911.         } else {
  1912.         wwarning(_("could not load icon file %s"), path);
  1913.         }
  1914.         free(path);
  1915.     }
  1916.     }
  1917.     WMGroupButtons(panel->mstyB[0], panel->mstyB[1]);
  1918.     WMGroupButtons(panel->mstyB[0], panel->mstyB[2]);
  1919.  
  1920.     WMMapSubwidgets(panel->mstyF);
  1921.  
  1922.  
  1923.     panel->taliF = WMCreateFrame(panel->optF);
  1924.     WMResizeWidget(panel->taliF, 110, 80);
  1925.     WMMoveWidget(panel->taliF, 15, 100);
  1926.     WMSetFrameTitle(panel->taliF, _("Title Alignment"));
  1927.  
  1928.     for (i = 0; i < 3; i++) {
  1929.     panel->taliB[i] = WMCreateRadioButton(panel->taliF);
  1930.     WMSetButtonAction(panel->taliB[i], titleAlignCallback, panel);
  1931.     switch (i) {
  1932.      case 0:
  1933.         WMSetButtonText(panel->taliB[i], _("Left"));
  1934.         break;
  1935.      case 1:
  1936.         WMSetButtonText(panel->taliB[i], _("Center"));
  1937.         break;
  1938.      case 2:
  1939.         WMSetButtonText(panel->taliB[i], _("Right"));
  1940.         break;
  1941.     }
  1942.     WMResizeWidget(panel->taliB[i], 90, 18);
  1943.     WMMoveWidget(panel->taliB[i], 10, 15 + 20*i);
  1944.     }
  1945.     WMGroupButtons(panel->taliB[0], panel->taliB[1]);
  1946.     WMGroupButtons(panel->taliB[0], panel->taliB[2]);
  1947.  
  1948.     WMMapSubwidgets(panel->taliF);
  1949.     
  1950.     WMMapSubwidgets(panel->optF);
  1951.  
  1952.     /**/
  1953.  
  1954.     WMRealizeWidget(panel->frame);
  1955.     WMMapSubwidgets(panel->frame);
  1956.  
  1957.     WMSetPopUpButtonSelectedItem(panel->secP, 0);
  1958.  
  1959.     showData(panel);
  1960.  
  1961.     changePage(panel->secP, panel);
  1962.  
  1963.     fillTextureList(panel->texLs);
  1964.  
  1965.     fillColorList(panel);
  1966.  
  1967.     panel->texturePanel = CreateTexturePanel(panel->win);
  1968. }
  1969.  
  1970.  
  1971.  
  1972. static void
  1973. setupTextureFor(WMList *list, char *key, char *defValue, char *title, 
  1974.         int index)
  1975. {
  1976.     WMListItem *item;
  1977.     TextureListItem *titem;
  1978.  
  1979.     titem = wmalloc(sizeof(TextureListItem));
  1980.     memset(titem, 0, sizeof(TextureListItem));
  1981.  
  1982.     titem->title = wstrdup(title);
  1983.     titem->prop = GetObjectForKey(key);
  1984.     if (!titem->prop || !PLIsArray(titem->prop)) {
  1985.         /* Maybe also give a error message to stderr that the entry is bad? */
  1986.     titem->prop = PLGetProplistWithDescription(defValue);
  1987.     } else {
  1988.     PLRetain(titem->prop);
  1989.     }
  1990.     titem->texture = PLGetDescription((proplist_t)titem->prop);
  1991.     titem->current = 1;
  1992.     titem->selectedFor = 1<<index;
  1993.     
  1994.     titem->ispixmap = isPixmap(titem->prop);
  1995.  
  1996.     titem->preview = renderTexture(WMWidgetScreen(list), titem->prop,
  1997.                    TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
  1998.  
  1999.     item = WMAddListItem(list, "");
  2000.     item->clientData = titem;
  2001. }
  2002.  
  2003.  
  2004.  
  2005. static void
  2006. showData(_Panel *panel)
  2007. {
  2008.     int i;
  2009.     char *str;
  2010.  
  2011.     str = GetStringForKey("MenuStyle");
  2012.     if (str && strcasecmp(str, "flat")==0) {
  2013.     panel->menuStyle = MSTYLE_FLAT;
  2014.     } else if (str && strcasecmp(str, "singletexture")==0) {
  2015.     panel->menuStyle = MSTYLE_SINGLE;
  2016.     } else {
  2017.     panel->menuStyle = MSTYLE_NORMAL;
  2018.     }
  2019.  
  2020.     str = GetStringForKey("TitleJustify");
  2021.     if (str && strcasecmp(str, "left")==0) {
  2022.     panel->titleAlignment = WALeft;
  2023.     } else if (str && strcasecmp(str, "right")==0) {
  2024.     panel->titleAlignment = WARight;
  2025.     } else {
  2026.     panel->titleAlignment = WACenter;
  2027.     }
  2028.  
  2029.     for (i = 0; i < sizeof(colorOptions)/(2*sizeof(char*)); i++) {
  2030.     WMColor *color;
  2031.  
  2032.     str = GetStringForKey(colorOptions[i*2]);
  2033.     if (!str)
  2034.         str = colorOptions[i*2+1];
  2035.  
  2036.     if (!(color = WMCreateNamedColor(WMWidgetScreen(panel->frame), str, False))) {
  2037.         color = WMCreateNamedColor(WMWidgetScreen(panel->frame), "#000000", False);
  2038.     }
  2039.  
  2040.     panel->colors[i] = color;
  2041.     }
  2042.     changeColorPage(panel->colP, panel);
  2043.  
  2044.     for (i = 0; i < sizeof(textureOptions)/(3*sizeof(char*)); i++) {
  2045.     setupTextureFor(panel->texLs, textureOptions[i*3],
  2046.             textureOptions[i*3+1], textureOptions[i*3+2], i);
  2047.     panel->textureIndex[i] = i;
  2048.     }
  2049.     updatePreviewBox(panel, EVERYTHING);
  2050.  
  2051.  
  2052.     for (i = 0; i < 3; i++) {
  2053.     WMSetButtonSelected(panel->mstyB[i], i==panel->menuStyle);
  2054.     WMSetButtonSelected(panel->taliB[i], i==panel->titleAlignment);
  2055.     }
  2056. }
  2057.  
  2058.  
  2059.  
  2060. static void
  2061. storeData(_Panel *panel)
  2062. {
  2063.     TextureListItem *titem;
  2064.     WMListItem *item;
  2065.     int i;
  2066.  
  2067.     for (i = 0; i < sizeof(textureOptions)/(sizeof(char*)*3); i++) {
  2068.     item = WMGetListItem(panel->texLs, panel->textureIndex[i]);
  2069.     titem = (TextureListItem*)item->clientData;
  2070.     SetObjectForKey(titem->prop, textureOptions[i*3]);
  2071.     }
  2072.  
  2073.     for (i = 0; i < 8; i++) {
  2074.     char *str;
  2075.  
  2076.     str = WMGetColorRGBDescription(panel->colors[i]);
  2077.  
  2078.     if (str) {
  2079.         SetStringForKey(str, colorOptions[i*2]);
  2080.         free(str);
  2081.     }
  2082.     }
  2083.  
  2084.     switch (panel->menuStyle) {
  2085.      case MSTYLE_SINGLE:
  2086.     SetStringForKey("singletexture", "MenuStyle");
  2087.     break;
  2088.      case MSTYLE_FLAT:
  2089.     SetStringForKey("flat", "MenuStyle");
  2090.     break;
  2091.      default:
  2092.      case MSTYLE_NORMAL:
  2093.     SetStringForKey("normal", "MenuStyle");
  2094.     break;
  2095.     }
  2096.     switch (panel->titleAlignment) {
  2097.      case WALeft:
  2098.     SetStringForKey("left", "TitleJustify");
  2099.     break;
  2100.      case WARight:
  2101.     SetStringForKey("right", "TitleJustify");
  2102.     break;
  2103.      default:
  2104.      case WACenter:
  2105.     SetStringForKey("center", "TitleJustify");
  2106.     break;
  2107.     }
  2108. }
  2109.  
  2110.  
  2111. static void
  2112. prepareForClose(_Panel *panel)
  2113. {
  2114.     proplist_t textureList;
  2115.     proplist_t texture;
  2116.     TextureListItem *titem;
  2117.     WMListItem *item;
  2118.     WMUserDefaults *udb = WMGetStandardUserDefaults();
  2119.     int i;
  2120.  
  2121.     textureList = PLMakeArrayFromElements(NULL, NULL);
  2122.  
  2123.     /* store list of textures */
  2124.     for (i = 7; i < WMGetListNumberOfRows(panel->texLs); i++) {
  2125.     item = WMGetListItem(panel->texLs, i);
  2126.     titem = (TextureListItem*)item->clientData;
  2127.  
  2128.     texture = PLMakeArrayFromElements(PLMakeString(titem->title),
  2129.                       PLRetain(titem->prop),
  2130.                       PLMakeString(titem->path),
  2131.                       NULL);
  2132.  
  2133.     PLAppendArrayElement(textureList, texture);
  2134.     }
  2135.  
  2136.     WMSetUDObjectForKey(udb, textureList, "TextureList");
  2137.     PLRelease(textureList);
  2138.     
  2139.     /* store list of colors */
  2140.     textureList = PLMakeArrayFromElements(NULL, NULL);
  2141.     for (i = 0; i < 24; i++) {
  2142.     WMColor *color;
  2143.     char *str;
  2144.  
  2145.     color = WMGetColorWellColor(panel->sampW[i]);
  2146.  
  2147.     str = WMGetColorRGBDescription(color);
  2148.     PLAppendArrayElement(textureList, PLMakeString(str));
  2149.     free(str);
  2150.     }
  2151.     WMSetUDObjectForKey(udb, textureList, "ColorList");
  2152.     PLRelease(textureList);
  2153.  
  2154.     WMSynchronizeUserDefaults(udb);
  2155. }
  2156.  
  2157.  
  2158.  
  2159. Panel*
  2160. InitAppearance(WMScreen *scr, WMWindow *win)
  2161. {
  2162.     _Panel *panel;
  2163.  
  2164.     panel = wmalloc(sizeof(_Panel));
  2165.     memset(panel, 0, sizeof(_Panel));
  2166.     
  2167.     panel->sectionName = _("Appearance Preferences");
  2168.  
  2169.     panel->description = _("Background texture configuration for windows,\n"
  2170.                "menus and icons.");
  2171.  
  2172.     panel->win = win;
  2173.  
  2174.     panel->callbacks.createWidgets = createPanel;
  2175.     panel->callbacks.updateDomain = storeData;
  2176.     panel->callbacks.prepareForClose = prepareForClose;
  2177.  
  2178.     AddSection(panel, ICON_FILE);
  2179.  
  2180.     return panel;
  2181. }
  2182.  
  2183.  
  2184.  
  2185. /****************************************************************************/
  2186.  
  2187.  
  2188.  
  2189. typedef struct ExtractPanel {
  2190.     WMWindow *win;
  2191.  
  2192.     WMLabel *label;
  2193.     WMList *list;
  2194.  
  2195.     WMButton *closeB;
  2196.     WMButton *extrB;
  2197. } ExtractPanel;
  2198.  
  2199.  
  2200.  
  2201. static void
  2202. OpenExtractPanelFor(_Panel *panel, char *path)
  2203. {
  2204.     ExtractPanel *epanel;
  2205.     WMColor *color;
  2206.     WMFont *font;
  2207.     WMScreen *scr = WMWidgetScreen(panel->win);
  2208.  
  2209.     epanel = wmalloc(sizeof(ExtractPanel));
  2210.     epanel->win = WMCreatePanelWithStyleForWindow(panel->win, "extract",
  2211.                           WMTitledWindowMask
  2212.                           |WMClosableWindowMask);
  2213.     WMResizeWidget(epanel->win, 245, 250);
  2214.     WMSetWindowTitle(epanel->win, _("Extract Texture"));
  2215.  
  2216.     epanel->label = WMCreateLabel(epanel->win);
  2217.     WMResizeWidget(epanel->label, 225, 18);
  2218.     WMMoveWidget(epanel->label, 10, 10);
  2219.     WMSetLabelTextAlignment(epanel->label, WACenter);
  2220.     WMSetLabelRelief(epanel->label, WRSunken);
  2221.  
  2222.     color = WMDarkGrayColor(scr);
  2223.     WMSetWidgetBackgroundColor(epanel->label, color);
  2224.     WMReleaseColor(color);
  2225.  
  2226.     color = WMWhiteColor(scr);
  2227.     WMSetLabelTextColor(epanel->label, color);
  2228.     WMReleaseColor(color);
  2229.  
  2230.     font = WMBoldSystemFontOfSize(scr, 12);
  2231.     WMSetLabelFont(epanel->label, font);
  2232.     WMReleaseFont(font);
  2233.  
  2234.     WMSetLabelText(epanel->label, _("Textures"));
  2235.  
  2236.     epanel->list = WMCreateList(epanel->win);
  2237.     WMResizeWidget(epanel->list, 225, 165);
  2238.     WMMoveWidget(epanel->list, 10, 30);
  2239.  
  2240.     
  2241.  
  2242.     epanel->closeB = WMCreateCommandButton(epanel->win);
  2243.     WMResizeWidget(epanel->closeB, 74, 24);
  2244.     WMMoveWidget(epanel->closeB, 165, 215);
  2245.     WMSetButtonText(epanel->closeB, _("Close"));
  2246.  
  2247.     epanel->extrB = WMCreateCommandButton(epanel->win);
  2248.     WMResizeWidget(epanel->extrB, 74, 24);
  2249.     WMMoveWidget(epanel->extrB, 80, 215);
  2250.     WMSetButtonText(epanel->extrB, _("Extract"));
  2251.  
  2252.     WMMapSubwidgets(epanel->win);
  2253.  
  2254.     
  2255.     /* take textures from file */
  2256.     
  2257.     
  2258.  
  2259.     WMRealizeWidget(epanel->win);
  2260.     
  2261.     WMMapWidget(epanel->win);
  2262. }
  2263.  
  2264.